/**
 * 滑动图表控制器
 * 
 * 该文件实现了图表滑动功能的核心逻辑
 * 支持左右滑动查看历史数据，管理时间窗口和数据偏移
 * 
 * 功能：
 * - 管理滑动偏移量和时间窗口
 * - 计算当前显示的数据范围
 * - 处理滑动手势和边界检查
 * - 支持全数据显示模式
 * 
 * 使用方法：
 * - 创建SlidingChartController实例
 * - 调用updateData()更新数据源
 * - 使用getVisibleData()获取当前显示的数据
 * - 通过slide()方法处理滑动操作
 * 
 * 原理：
 * - 维护一个时间偏移量来控制显示窗口
 * - 根据时间窗口大小和偏移量过滤数据
 * - 支持边界检查防止滑动超出数据范围
 */

package com.example.brain_wave.ui.components

import androidx.compose.runtime.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

/**
 * 滑动图表控制器
 */
class SlidingChartController {
    
    // 所有数据
    private val _allData = MutableStateFlow<List<BrainWaveDataPoint>>(emptyList())
    val allData: StateFlow<List<BrainWaveDataPoint>> = _allData.asStateFlow()
    
    // 当前显示的数据
    private val _visibleData = MutableStateFlow<List<BrainWaveDataPoint>>(emptyList())
    val visibleData: StateFlow<List<BrainWaveDataPoint>> = _visibleData.asStateFlow()
    
    // 时间窗口（秒）
    private val _timeWindowSeconds = MutableStateFlow(30)
    val timeWindowSeconds: StateFlow<Int> = _timeWindowSeconds.asStateFlow()
    
    // 时间偏移量（毫秒），负值表示查看历史数据
    private val _timeOffset = MutableStateFlow(0L)
    val timeOffset: StateFlow<Long> = _timeOffset.asStateFlow()
    
    // 是否为全数据显示模式
    private val _isShowingAllData = MutableStateFlow(false)
    val isShowingAllData: StateFlow<Boolean> = _isShowingAllData.asStateFlow()
    
    // 是否可以向左滑动（查看更早的数据）
    private val _canSlideLeft = MutableStateFlow(false)
    val canSlideLeft: StateFlow<Boolean> = _canSlideLeft.asStateFlow()
    
    // 是否可以向右滑动（查看更新的数据）
    private val _canSlideRight = MutableStateFlow(false)
    val canSlideRight: StateFlow<Boolean> = _canSlideRight.asStateFlow()
    
    /**
     * 更新数据源
     */
    fun updateData(newData: List<BrainWaveDataPoint>) {
        _allData.value = newData.sortedBy { it.timestamp }
        updateVisibleData()
    }
    
    /**
     * 设置时间窗口
     */
    fun setTimeWindow(seconds: Int) {
        if (seconds == SwimLaneChartConfig.ALL_DATA_WINDOW) {
            _isShowingAllData.value = true
            _timeWindowSeconds.value = 0
            _timeOffset.value = 0L
        } else {
            _isShowingAllData.value = false
            _timeWindowSeconds.value = seconds
            // 重置到最新数据
            _timeOffset.value = 0L
        }
        updateVisibleData()
    }
    
    /**
     * 滑动操作
     * @param deltaMs 时间偏移量变化（毫秒）
     */
    fun slide(deltaMs: Long) {
        if (_isShowingAllData.value) return // 全数据模式不支持滑动
        
        val newOffset = _timeOffset.value + deltaMs
        val maxOffset = calculateMaxOffset()
        val minOffset = 0L
        
        _timeOffset.value = newOffset.coerceIn(minOffset, maxOffset)
        updateVisibleData()
    }
    
    /**
     * 重置到最新数据
     */
    fun resetToLatest() {
        _timeOffset.value = 0L
        updateVisibleData()
    }
    
    /**
     * 跳转到最早数据
     */
    fun jumpToEarliest() {
        if (_isShowingAllData.value) return
        
        _timeOffset.value = calculateMaxOffset()
        updateVisibleData()
    }
    
    /**
     * 更新可见数据
     */
    private fun updateVisibleData() {
        val allDataList = _allData.value
        
        if (allDataList.isEmpty()) {
            _visibleData.value = emptyList()
            _canSlideLeft.value = false
            _canSlideRight.value = false
            return
        }
        
        if (_isShowingAllData.value) {
            // 全数据显示模式
            _visibleData.value = allDataList
            _canSlideLeft.value = false
            _canSlideRight.value = false
            return
        }
        
        // 时间窗口模式 - 修复：基于数据的实际时间范围
        val latestDataTime = allDataList.maxOfOrNull { it.timestamp } ?: System.currentTimeMillis()
        val windowMs = _timeWindowSeconds.value * 1000L
        val endTime = latestDataTime - _timeOffset.value
        val startTime = endTime - windowMs
        
        println("SlidingChartController: 时间窗口过滤 - 窗口: ${_timeWindowSeconds.value}s, 偏移: ${_timeOffset.value}ms")
        println("SlidingChartController: 数据时间范围 - 开始: $startTime, 结束: $endTime")
        println("SlidingChartController: 最新数据时间: $latestDataTime")
        
        val filteredData = allDataList.filter { dataPoint ->
            val inRange = dataPoint.timestamp >= startTime && dataPoint.timestamp <= endTime
            if (!inRange) {
                println("SlidingChartController: 过滤掉数据点 - 时间戳: ${dataPoint.timestamp}")
            }
            inRange
        }
        
        println("SlidingChartController: 过滤后数据点数量: ${filteredData.size} / ${allDataList.size}")
        
        _visibleData.value = filteredData
        
        // 更新滑动状态
        val earliestTime = allDataList.firstOrNull()?.timestamp ?: latestDataTime
        
        _canSlideLeft.value = startTime > earliestTime
        _canSlideRight.value = _timeOffset.value > 0L
    }
    
    /**
     * 计算最大偏移量
     */
    private fun calculateMaxOffset(): Long {
        val allDataList = _allData.value
        if (allDataList.isEmpty()) return 0L
        
        val currentTime = System.currentTimeMillis()
        val windowMs = _timeWindowSeconds.value * 1000L
        val earliestTime = allDataList.first().timestamp
        val latestTime = allDataList.last().timestamp
        
        // 确保窗口的开始时间不早于最早数据时间
        val maxEndTime = earliestTime + windowMs
        return (currentTime - maxEndTime).coerceAtLeast(0L)
    }
    
    /**
     * 获取当前显示时间范围的描述
     */
    fun getTimeRangeDescription(): String {
        if (_isShowingAllData.value) {
            return "显示全部数据"
        }
        
        val visibleDataList = _visibleData.value
        if (visibleDataList.isEmpty()) {
            return "无数据"
        }
        
        val startTime = visibleDataList.first().timestamp
        val endTime = visibleDataList.last().timestamp
        val currentTime = System.currentTimeMillis()
        
        return if (_timeOffset.value == 0L) {
            "显示最新 ${_timeWindowSeconds.value} 秒"
        } else {
            val offsetSeconds = _timeOffset.value / 1000
            "历史数据 (${offsetSeconds}秒前)"
        }
    }
}

/**
 * Composable函数，用于创建和记住SlidingChartController实例
 */
@Composable
fun rememberSlidingChartController(): SlidingChartController {
    return remember { SlidingChartController() }
}